import FV from '@/common/FV.js';
import C from '@/common/C.js';
import Vue from 'vue';

/**
 * 公共的工具js
 */
module.exports = {
	/** 获取设备 */
	get_device: function() {
		let si = uni.getSystemInfoSync();
		return `${si.model}=${si.system}=${si.version}`;
	},
	/** 是否是ios设备 */
	is_ios: function() {
		return this.is_platform('ios');
	},
	/** 是否是android设备 */
	is_android: function() {
		return this.is_platform('android');
	},
	/** 是否是windows设备 */
	is_windows: function() {
		return this.is_platform('windows');
	},
	/** 是否是mac设备 */
	is_mac: function() {
		return this.is_platform('mac');
	},
	/** 是否是linux设备 */
	is_linux: function() {
		return this.is_platform('linux');
	},
	/**
	 * 判断-平台
	 * @param {Object} val 设备名
	 */
	is_platform(val) {
		console.log('当前平台', uni.getSystemInfoSync().platform);
		return uni.getSystemInfoSync().platform.indexOf(val) != -1;
	},
	/**
	 * 验证用户是否开启位置权限
	 * @param {Object} callback 回调函数
	 */
	valLocationSet(callback) {
		const U = this;

		//#ifndef APP-PLUS || H5
		uni.getSetting({
			success(res) {
				let set = res.authSetting;
				console.log('是否授权位置', set);

				if (!set['scope.userLocationBackground']) {
					// 地址未授权
					U.qmodal({
						title: '温馨提示',
						text: '请授权定位服务，以便更好的体验！',
						success: res => {
							if (res.confirm) {
								uni.openSetting({
									success(res) {
										console.log('打开设置成功', res.authSetting)
									}
								})
							}
						}
					});
				} else {
					callback();
				}
			}
		});

		//#endif

		//#ifdef APP-PLUS
		callback();
		//#endif
	},
	// 获取-用户位置
	getLocation: function() {

		let U = this;
	//#ifdef APP-PLUS || H5 || MP-ALIPAY
	uni.getLocation({
		type: 'gcj02',
		geocode: true,
		success: function(res) {
			// console.log('****获取用户位置--begin*********************');
			// console.log('位置数据', res);
			// console.log('当前位置的经度：' + res.longitude);
			// console.log('当前位置的纬度：' + res.latitude);
			// console.log('当前位置的速度：' + res.speed);
			// console.log('****获取用户位置--end***********************');
	
			U.saveLocInfo(res);
		},
		fail(err) {
			console.log('获取当前坐标错误', err);
		}
	});
	//#endif
	
	//#ifdef MP-WEIXIN
	uni.authorize({
		scope: 'scope.userLocationBackground',
		success(res) {
			// console.log('授权成功', res);
	
			wx.startLocationUpdateBackground({
				success: (res) => {
					wx.onLocationChange(U.saveLocInfo);
				},
				fail: (res) => {
					console.log('开启后台定位失败。(' + JSON.stringify(res) + ')');
				}
			});
	
		},
		fail(err) {
			console.log('暂未授权', err);
		}
	});
	//#endif
		
		

	},
	/**
	 * 请求后台-保存地址信息至服务器
	 * @param {Object} res 地址信息 
	 */
	saveLocInfo(res) {

		let U = Vue.prototype.U;
		// console.log('正在保存位置信息', res);

		// 经度
		let lng = res.longitude || '';
		lng = U.num(lng, 6);

		// 纬度
		let lat = res.latitude || '';
		lat = U.num(lat, 6);

		// 速度
		let speed = res.speed || '';
		speed = speed ? speed : '0';

		// 位置精确度
		let accuracy = res.accuracy || '';
		accuracy = U.num(accuracy, 3);

		// 位置高度
		let altitude = res.altitude || '';
		altitude = U.num(altitude, 3);

		// 详细位置（仅App有）
		let address = res.address || '';
		if (!address) {
			address = '';
		} else {
			let arr = [];
			if (address.province) arr.push(address.province);
			if (address.city) arr.push(address.city);
			if (address.district) arr.push(address.district);
			if (address.street) arr.push(address.street);
			if (address.poiName) arr.push(address.poiName);
			if (address.streetNum) arr.push(address.streetNum);

			address = arr.join('=');
		}

		// 将数据保存至缓存中
		let location = uni.getStorageSync(C.location);
		// 未保存坐标 || 坐标数据（坐标小数点后3位作比较，因为后3位才精确到米）不一致，则保存至缓存
		let todayDate = U.date2str(new Date(), 'yyyy-MM-dd');
		console.log('11111', );
		// if(!location || todayDate != location.date || (U.num(location.lng, 3) != U.num(lng, 3) && U.num(location.lat, 3) != U.num(lat, 3))){
		// 	console.log('位置数据', res);
		// 	console.log('11111',);
		// 	let obj = {
		// 		date: U.date2str(new Date(), 'yyyy-MM-dd'),
		// 		lng: lng, 
		// 		lat: lat, 
		// 		speed: speed,
		// 		accuracy: accuracy,
		// 		altitude: altitude,
		// 		address: address
		// 	};
		// 	uni.setStorageSync(C.location, obj);
		// 	console.log('缓存中的位置数据', uni.getStorageSync(C.location));

		// 	// 请求后台接口-保存坐标信息(需登录)
		// 	let luuid = uni.getStorageSync(C.uuid);
		// 	if(luuid){
		// 		// 获取-设备
		// 		let device = U.get_device();
		// 		console.log('访问设备', device);

		// 		let ps = {device: device, lat: obj.lat, lng: obj.lng, address: obj.address};
		// 		Vue.prototype.$u.api.addMapPointTrack(ps).then(res => {
		// 			if(res.code != 1){
		// 				console.log(res.msg,'addMapPointTrack');
		// 			}else{
		// 				console.log(res.msg,'addMapPointTrack');
		// 			}
		// 		});
		// 	}
		// }
		let obj = {
			date: U.date2str(new Date(), 'yyyy-MM-dd'),
			lng: lng,
			lat: lat,
			speed: speed,
			accuracy: accuracy,
			altitude: altitude,
			address: address
		};
		uni.setStorageSync(C.location, obj);
		// console.log('缓存中的位置数据', uni.getStorageSync(C.location));

		// 请求后台接口-保存坐标信息(需登录)
		let luuid = uni.getStorageSync(C.uuid);
		if (luuid) {
			// 获取-设备
			let device = U.get_device();
			// console.log('访问设备', device);

			let ps = {
				deviceInfo: device,
				lat: obj.lat,
				lng: obj.lng,
				address: obj.address
			};
			let times = uni.getStorageSync('times')
			let times_off = true
			if(times){
				let timestamp = Date.now() 
				let fiveMinutesAgo = timestamp - (5 * 60 * 1000)
				if(Number(timestamp) > Number(times) + (5 * 60 * 1000)){
					
					 times_off = true
					 let timestamp = Date.now()
					 uni.setStorageSync('times', timestamp);
				}else{
					
					 times_off = false
				}
				
			}else{
				let timestamp = Date.now()
				uni.setStorageSync('times', timestamp);
			
				times_off = true
			}
			
			if(times_off){
				
				Vue.prototype.$u.api.addMapPointTrack(ps).then(res => {
					if (res.code != 1) {
						
					} else {
						
					}
				});
			}
			
		}
	},

	/**
	 * 获取-之前的页面$vm对象（方便调用方法）
	 * @param {Object} {delta = 回退的页面}  
	 */
	getPPage(delta = 1) {
		const pages = getCurrentPages();
		if (pages.length > 1) {
			const prePage = pages[pages.length - delta - 1];
			// 触发父页面中的方法
			return prePage.$vm;
		}
		return null;
	},


	/**
	 * 深度拷贝对象
	 * @param {Object} obj 欲拷贝的对象
	 */
	scopy(obj) {
		return Vue.prototype._.cloneDeep(obj);
	},
	/**
	 * 去掉前后空格（uView中的js方法）
	 * @param {Object} val 值
	 * @param {Object} pos 去掉空格位置（both-两端（默认）left-左边 right-右边 all-所有 ）
	 */
	trim(val, pos = 'both') {
		if (pos == 'left') {
			// 去掉左边空格
			return val.replace(/^[\s]+/g, '');
		} else if (pos == 'right') {
			// 去掉右边空格
			return val.replace(/[\s]+$/g, '');
		} else if (pos == 'all') {
			// 去掉所有空格
			val = val.replace(/(^\s+)|(\s+$)/g, '');
			return val.replace(/\s/g, '');
		} else {
			// 去掉前后两端空格
			return val.replace(/(^[\s]+|[\s]+$)/g, '');
		}

		return val;
	},

	/**
	 * 全局加载
	 * @param text 加载显示的文本
	 */
	qloading(text) {
		uni.showLoading({
			title: text || '加载中...',
			mask: true
		});
	},
	/**
	 * 关闭-全局加载
	 */
	qclose() {
		uni.hideLoading();
	},
	/**
	 * 消息提示框
	 * @param {Object} obj 设置对象
	 */
	qmsg(obj) {
		uni.showToast({
			// 提示的内容，长度与 icon 取值有关
			title: obj.title ? obj.title : '提示内容',
			// 图标 success/error/none/loading（支付宝小程序不支持）
			icon: obj.icon ? obj.icon : 'none',
			// 是否显示透明蒙层，防止触摸穿透
			mask: true,
			// 提示的延迟时间，单位毫秒
			duration: obj.time ? obj.time : 2000,
			// 成功回调函数
			success: obj.success ? obj.success : function() {},
			// 失败回调函数
			fail: obj.fail ? obj.fail : function() {},
			// 接口调用结束的回调函数（调用成功、失败都会执行）
			complete: obj.complete ? obj.complete : function() {}
		});
	},
	/**
	 * 普通-提示框
	 * @param {string} title 标题
	 * @param {number} time  关闭时间  
	 * @param {Function} success  	成功后的回调方法
	 */
	qinfo(title = '普通提示框标题', time = 2000, success) {
		this.qmsg({
			title: title,
			time: time,
			icon: 'none',
			success: success
		});
		return false;
	},
	/**
	 * 成功-提示框
	 * @param {string} title 		标题
	 * @param {number} time  		关闭时间 
	 * @param {Function} success  	成功后的回调方法
	 */
	qsuccess(title = '成功标题', time = 3000, success) {
		this.qmsg({
			title: title,
			time: time,
			icon: 'success',
			success: success
		});
		return false;
	},
	/**
	 * 错误-提示框
	 * @param {string} title 标题
	 * @param {number} time  关闭时间  
	 */
	qerror(title = '错误标题', time = 3000) {
		this.qmsg({
			title: title,
			time: time,
			icon: 'error'
		});
		return false;
	},
	/**
	 * 错误-提示框(返回false)
	 * @param {string} title 标题
	 * @param {number} time  关闭时间  
	 */
	qerrorFalse(title = '错误标题', time = 3000) {
		this.qmsg({
			title: title,
			time: time,
			icon: 'error'
		});
		return false;
	},
	/**
	 * 加载-提示框
	 * @param {string} title 标题
	 * @param {number} time  关闭时间  
	 */
	qload(title = '加载标题', time = 3000) {
		this.qmsg({
			title: title,
			time: time,
			icon: 'loading'
		});
	},
	/**
	 * 模态弹框
	 * @param {Object} obj 设置参数对象
	 */
	qmodal(obj) {
		uni.showModal({
			title: obj.title ? obj.title : '模态弹框标题',
			content: obj.text ? obj.text : '出错啦，请联系管理员',
			showCancel: obj.cancelBtn ? obj.cancelBtn : true,
			cancelText: obj.cancelText ? obj.cancelText : '取消',
			cancelColor: obj.cancelColor ? obj.cancelColor : '#000000',
			confirmText: obj.okText ? obj.okText : '确定',
			confirmColor: obj.okColor ? obj.okColor : '#000000',
			// 成功后的回调函数 confirm：为 true 时，表示用户点击了确定按钮 cancel：为 true 时，表示用户点击了取消
			success: obj.success ? obj.success : function() {},
			fail: obj.fail ? obj.fail : function() {},
			complete: obj.complete ? obj.complete : function() {}
		});
	},
	/**
	 * 普通-弹框
	 * @param {string} text 弹框内容
	 */
	qalert(text) {
		this.qmodal({
			title: '提示',
			text: text,
			showCancel: false
		});
	},
	/**
	 * 确认-弹框
	 * @param {string} text 弹框内容
	 * @param {Function} success 成功后回调函数
	 */
	qconfim(text, success) {
		this.qmodal({
			title: '确认提示',
			text: text,
			success: success
		});
	},

	/**
	 * uView框架toast提示
	 * @param {Object} that 	所在的域shis对象
	 * @param {Object} ps 		设置对象
	 * @param {Object} refname 	ref名称
	 */
	qtoast(that, ps, refname = 'qtoast') {
		that.$refs[refname].show({
			// 标题
			title: ps.title || '提示',
			// 主题类型
			type: ps.type || 'default',
			// toast的持续时间，单位ms
			duration: ps.duration || 2000,
			// toast结束跳转的url，不填不跳转
			url: ps.url || '',
			// 配置了url值携带的参数
			params: ps.ps || {},
			// toast结束后，跳转tab页面时需要
			isTab: ps.isTab || false,
			// toast结束后，是否返回上一页
			back: ps.back || false,
			// 是否显示显示type对应的图标
			icon: ps.icon || true,
			// toast出现的位置
			position: ps.position || 'center',
			callback: ps.callback || function() {}
		});
	},
	/**
	 * 普通-提示框
	 * @param {string} title 	提示内容
	 * @param {Object} that 	所在的域shis对象
	 * @param {number} time  	延迟关闭时间  
	 * @param {Object} refname 	ref名称
	 */
	qtinfo(title = '普通提示', that, time = 3000, refname) {
		this.qtoast(that, {
			title: title,
			duration: time
		}, refname);
		return false;
	},
	/**
	 * 成功-提示框
	 * @param {string} title 	提示内容
	 * @param {Object} that 	所在的域shis对象
	 * @param {number} time  	延迟关闭时间  
	 * @param {Object} refname 	ref名称
	 */
	qtsuccess(title = '普通提示', that, time = 3000, refname) {
		this.qtoast(that, {
			title: title,
			type: 'success',
			duration: time
		}, refname);
		return false;
	},
	/**
	 * 错误-提示框
	 * @param {string} title 	提示内容
	 * @param {Object} that 	所在的域shis对象
	 * @param {number} time  	延迟关闭时间  
	 * @param {Object} refname 	ref名称
	 */
	qterror(title = '普通提示', that, time = 3000, refname) {
		this.qtoast(that, {
			title: title,
			type: 'error',
			duration: time
		}, refname);
		return false;
	},
	/**
	 * 警告-提示框
	 * @param {string} title 	提示内容
	 * @param {Object} that 	所在的域shis对象
	 * @param {number} time  	延迟关闭时间  
	 * @param {Object} refname 	ref名称
	 */
	qtwarning(title = '普通提示', that, time = 3000, refname) {
		this.qtoast(that, {
			title: title,
			type: 'warning',
			duration: time
		}, refname);
		return false;
	},




	/**
	 * 少于2位补0
	 * @param n 传入的数字
	 */
	pad(n) {
		return (n < 10 ? `0${n}` : n.toString());
	},
	/**
	 * 将一个时间字符串转换成时间类型
	 * @param dateStr 时间字符串
	 * @returns 时间对象
	 */
	str2date(dateStr) {
		if (dateStr.indexOf('-') != -1) dateStr = dateStr.replace(/-/g, '/');
		return new Date(dateStr);
	},
	/**
	 * 将一个时间类型转换成字符串
	 * @param date 时间对象
	 * @returns 时间字符串
	 */
	date2str(date, fmt) {
		return this.datefmt(date, fmt);
	},
	/**
	 * 时间转换为字符串
	 * @param date 时间
	 * @param format 格式
	 */
	datefmt(date, format = 'yyyy-MM-dd HH:mm') {
		let fmt = format;

		if (!date) return '';

		// 传入的是时间字符串，则转换成时间类型
		if (typeof(date) === 'string') date = this.str2date(date);
		if (format.indexOf('-') != -1) format = format.replace(/-/g, '/');

		const pad = (n) => (n < 10 ? `0${n}` : n.toString());

		let res = format
			.replace('yyyy', date.getFullYear())
			.replace('MM', pad(date.getMonth() + 1))
			.replace('dd', pad(date.getDate()))
			.replace('HH', pad(date.getHours()))
			.replace('mm', pad(date.getMinutes()))
			.replace('ss', pad(date.getSeconds()));
		if (fmt.indexOf('-') != -1) res = res.replace(/\//g, '-');

		return res;
	},
	/**
	 * 获取月份第一天
	 * @param date 日期字符串[yyyy-mm-dd] | Date类型的日期
	 * @param isStr 返回值是否为字符串：1-是；否则-不是；
	 * @param format 时间格式，默认：yyyy-mm-dd HH:MM:ss
	 */
	getMonthFirstDay(date, isStr, format) {
		/** 年份 */
		let year = null;
		/** 月份 */
		let nmonth = null;
		/** 操作日期 */
		let cdate = null;

		if (typeof(date) === 'string') {
			cdate = this.str2date(date);
		} else if (typeof(date) === 'object') {
			cdate = date;
		}

		year = cdate.getFullYear();
		nmonth = cdate.getMonth();

		let res = new Date(year, nmonth, 1);
		if (isStr === 1) res = this.datefmt(res, format);

		return res;
	},
	/**
	 * 获取月份最后一天
	 * @param date 日期字符串[yyyy-mm-dd] | Date类型的日期
	 * @param isStr 返回值是否为字符串：1-是；否则-不是；
	 * @param format 时间格式，默认：yyyy-MM-dd HH:mm:ss
	 */
	getMonthLastDay(date, isStr, format) {
		/** 年份 */
		let year = null;
		/** 月份 */
		let nmonth = null;
		/** 操作日期 */
		let cdate = null;

		if (typeof(date) === 'string') {
			cdate = this.str2date(date);
		} else if (typeof(date) === 'object') {
			cdate = date;
		}

		year = cdate.getFullYear();
		nmonth = cdate.getMonth() + 1;

		let res = new Date(year, nmonth, 0);
		if (isStr === 1) res = this.datefmt(res, format);

		return res;
	},
	/**
	 * 获取-两个时间之间相差多少天
	 * @param stime 开始时间
	 * @param etime 结束时间
	 */
	getSEDifferDay(stime, etime) {
		let that = this,
			day = 0;

		let st = that.str2date(stime),
			et = that.str2date(etime);

		day = (et.getTime() - st.getTime()) / (1000 * 60 * 60 * 24);

		return day;
	},
	/**
	 * 获取-今天起止时间段 如：[2021-05-01 00:00:00, 2021-05-01 23:59:59]
	 * @param day 增加的天数（可为负数）
	 */
	getSEToday(day) {
		let todaytime = new Date().getTime();
		if (day && FV.isPosOrNegInt(day)) {
			day = parseInt(day);
			if (day != 0) todaytime += day * 1000 * 60 * 60 * 24;
		}

		let date = this.date2str(new Date(todaytime), 'yyyy-MM-dd');
		return [`${date} 00:00:00`, `${date} 23:59:59`];
	},
	/**
	 * 处理起止时间显示方式
	 * @param {string} st 开始时间
	 * @param {string} et 结束时间
	 * @return {string} 2021年10月10号 10:30 ~ 20:30/2021年10月10号 10:30 ~ 2021年10月10号 10:30
	 */
	sedate(st, et, t) {
		let U = this,
			res = '';

		if (!st || !et) return res;

		if (t) {
			if (t == 1) {
				// 2021年10月10号 10:30
				st = U.datefmt(st, 'yyyy年MM月dd号 HH:mm'), et = U.datefmt(et, 'yyyy年MM月dd号 HH:mm');
				let sdate = st.split(' ')[0],
					edate = et.split(' ')[0];
				let stime = st.split(' ')[1],
					etime = et.split(' ')[1];
				if (sdate == edate) {
					// 起止日期在同一天
					res = `${sdate} ${stime} ~ ${etime}`;
				} else {
					res = `${st} ~ ${et}`;
				}
			} else {
				// 2021年10月10号
				st = U.datefmt(st, 'yyyy年MM月dd号'), et = U.datefmt(et, 'yyyy年MM月dd号');
				// 开始年份, 结束年份
				let syear = st.substring(0, 4),
					eyear = et.substring(0, 4);
				// 开始年月份, 结束年月份
				let smonth = st.substring(0, 7),
					emonth = et.substring(0, 7);
				// 开始年月日, 结束年月日
				let sday = st.substring(0, 10),
					eday = et.substring(0, 10);

				if (syear != eyear) {
					// 年份不同，则显示：2021年10月10号 ~ 2022年10月10号
					res = `${st} ~ ${et}`;
				} else if (smonth != emonth) {
					// 月份不同，则显示：2021年10月10号 ~ 12月10号
					res = `${st} ~ ${et.substring(5)}`;
				} else if (sday != eday) {
					// 号数不同，则显示：2021年10月10号 ~ 12号
					res = `${st} ~ ${et.substring(8)}`;
				} else {
					// 时间不同，则显示：2021年10月10号
					res = `${st}`;
				}
			}
		} else {
			// 2021年10月10号 10:30
			st = U.datefmt(st, 'yyyy年MM月dd号 HH:mm'), et = U.datefmt(et, 'yyyy年MM月dd号 HH:mm');
			// 开始年份, 结束年份
			let syear = st.substring(0, 4),
				eyear = et.substring(0, 4);
			// 开始年月份, 结束年月份
			let smonth = st.substring(0, 7),
				emonth = et.substring(0, 7);
			// 开始年月日, 结束年月日
			let sday = st.substring(0, 10),
				eday = et.substring(0, 10);

			if (syear != eyear) {
				// 年份不同，则显示：2021年10月10号 10:30 ~ 2022年10月10号 10:30
				res = `${st} ~ ${et}`;
			} else if (smonth != emonth) {
				// 月份不同，则显示：2021年10月10号 10:30 ~ 12月10号 10:30
				res = `${st} ~ ${et.substring(5)}`;
			} else if (sday != eday) {
				// 号数不同，则显示：2021年10月10号 10:30 ~ 12号 10:30
				res = `${st} ~ ${et.substring(8)}`;
			} else {
				// 时间不同，则显示：2021年10月10号 10:30 ~ 12:30
				res = `${st} ~ ${et.substring(12)}`;
			}
		}

		return res;
	},

	/** 获取-登录用户位置信息 */
	getLngLat() {
		return uni.getStorageSync(C.location);
	},

	/**
	 * 数字处理
	 * @param {*} val 处理的数字 
	 * @param {*} len 保留小数位数
	 */
	num(val, len) {
		if (!val) return 0;

		// 默认保留两位小数
		if (!len) len = 2;

		val = val + '';

		if (!/^[0-9]+.?[0-9]*$/.test(val)) {
			return val; // 不是数字，原字符返回
		} else if (val.indexOf('.') != -1) {
			// 存在小数点，判断小数点后面的位数，如果大于传入的长度，则截取
			let v = val.substring(val.indexOf('.') + 1);
			if (v.length > len) val = val.substring(0, val.indexOf('.') + len + 1);

			return parseFloat(val);
		} else {
			// 不存在小数点，转换成浮点数字返回
			return parseFloat(val);
		}
	},
	/**
	 * 小程序打开第三方地图
	 * @param {string} lat 	纬度 
	 * @param {string} lng 	经度
	 * @param {string} name 地点名称
	 * @param {string} address 详细地址
	 */
	toMapMp(lat, lng, name, address) {
		uni.openLocation({
			longitude: Number(lng),
			latitude: Number(lat),
			name: name,
			address: address || name
		});
	},
	/**
	 * App打开第三方地图
	 * @param {string} lat 	纬度 
	 * @param {string} lng 	经度
	 * @param {string} name 地点名称
	 */
	toMapApp(lat, lng, name) {
		let url = "";
		if (plus.os.name == "Android") { //判断是安卓端
			plus.nativeUI.actionSheet({ //选择菜单
				title: "选择地图应用",
				cancel: "取消",
				buttons: [{
					title: "腾讯地图"
				}, {
					title: "百度地图"
				}, {
					title: "高德地图"
				}]
			}, function(e) {
				switch (e.index) {
					//下面是拼接url,不同系统以及不同地图都有不同的拼接字段
					case 1:
						//注意referer=xxx的xxx替换成你在腾讯地图开发平台申请的key
						url = `qqmap://map/geocoder?coord=${lat},${lng}&referer=xxx`;
						break;
					case 2:
						url =
							`baidumap://map/marker?location=${lat},${lng}&title=${name}&coord_type=gcj02&src=andr.baidu.openAPIdemo`;
						break;
					case 3:
						url =
							`androidamap://viewMap?sourceApplication=appname&poiname=${name}&lat=${lat}&lon=${lng}&dev=0`;
						break;
					default:
						break;
				}
				if (url != "") {
					url = encodeURI(url);
					//plus.runtime.openURL(url,function(e){})调起手机APP应用
					plus.runtime.openURL(url, function(e) {
						plus.nativeUI.alert("本机未安装指定的地图应用");
					});
				}
			})
		} else {
			// iOS上获取本机是否安装了百度高德地图，需要在manifest里配置
			// 在manifest.json文件app-plus->distribute->apple->urlschemewhitelist节点下添加
			//（如urlschemewhitelist:["iosamap","baidumap"]）  
			plus.nativeUI.actionSheet({
				title: "选择地图应用",
				cancel: "取消",
				buttons: [{
					title: "腾讯地图"
				}, {
					title: "百度地图"
				}, {
					title: "高德地图"
				}]
			}, function(e) {
				switch (e.index) {
					case 1:
						url = `qqmap://map/geocoder?coord=${lat},${lng}&referer=xxx`;
						break;
					case 2:
						url =
							`baidumap://map/marker?location=${lat},${lng}&title=${name}&content=${name}&src=ios.baidu.openAPIdemo&coord_type=gcj02`;
						break;
					case 3:
						url =
							`iosamap://viewMap?sourceApplication=applicationName&poiname=${name}&lat=${lat}&lon=${lng}&dev=0`;
						break;
					default:
						break;
				}
				if (url != "") {
					url = encodeURI(url);
					plus.runtime.openURL(url, function(e) {
						plus.nativeUI.alert("本机未安装指定的地图应用");
					});
				}
			})
		}
	},




}